home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / getch.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  9.2 KB  |  341 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. /* undefine any macros for functions defined in this module */
  24. #undef    getch
  25. #undef    wgetch
  26. #undef    mvgetch
  27. #undef    mvwgetch
  28. #undef    ungetch
  29.  
  30. /* undefine any macros for functions called by this module if in debug mode */
  31. #ifdef PDCDEBUG
  32. #  undef    wrefresh
  33. #  undef    nocbreak
  34. #  undef    move
  35. #  undef    wmove
  36. #endif
  37.  
  38. #ifdef PDCDEBUG
  39. char *rcsid_getch  = "$Id$";
  40. #endif
  41.  
  42. /*man-start*********************************************************************
  43.  
  44.   Name:                                                         getch
  45.  
  46.   Synopsis:
  47.       int getch(void);
  48.       int wgetch(WINDOW *win);
  49.       int mvgetch(int y, int x);
  50.       int mvwgetch(WINDOW *win, int y, int x);
  51.       int ungetch(int ch);
  52.  
  53.   X/Open Description:
  54.      With the getch(), wgetch(), mvgetch(), and mvwgetch() functions, 
  55.      a character is read from the terminal associated with the window. 
  56.      In nodelay mode, if there is no input
  57.      waiting, the value ERR is returned. In delay mode, the program will
  58.      hang until the system passes text through to the program.
  59.      Depending on the setting of cbreak(), this will be after one
  60.      character or after the first newline.  Unless noecho() has
  61.      been set, the character will also be echoed into the designated
  62.      window.
  63.  
  64.      If keypad() is TRUE, and a function key is pressed, the token for
  65.      that function key will be returned instead of the raw characters.
  66.      Possible function keys are defined in <curses.h> with integers
  67.      beginning with 0401, whose names begin with KEY_.  If a character
  68.      is received that could be the beginning of a function key (such as
  69.      escape), curses will set a timer.  If the remainder of the sequence
  70.      does not come in within the designated time, the character will be
  71.      passed through, otherwise the function key value will be returned.
  72.      For this reason, on many terminals, there will be a delay after a
  73.      user presses the escape key before the escape is returned to the
  74.      program.  (Use by a programmer of the escape key for a single
  75.      character function is discouraged.)
  76.  
  77.      If nodelay(win,TRUE) has been called on the window and no input is
  78.      waiting, the value ERR is returned.
  79.  
  80.      The ungetch() function places ch back onto the input queue to be
  81.      returned by the next call to wgetch().
  82.  
  83.      NOTE: getch(), mvgetch() and mvwgetch() are implemented as macros.
  84.  
  85.   PDCurses Description:
  86.      Given the nature of the PC, there is no such timer set for an
  87.      incoming ESCAPE value, because function keys generate unique
  88.      scan codes that are not prefixed with the ESCAPE character.
  89.  
  90.      Also, note that the getch() definition will conflict  with
  91.      many DOS compiler's runtime libraries.
  92.  
  93.   X/Open Return Value:
  94.      This functions return ERR or the value of the character, meta 
  95.      character or function key token.
  96.  
  97.   X/Open Errors:
  98.      No errors are defined for this function.
  99.  
  100.   Portability                             X/Open    BSD    SYS V
  101.                                           Dec '88
  102.       getch                                 Y        Y       Y
  103.       wgetch                                Y        Y       Y
  104.       mvgetch                               Y        Y       Y
  105.       mvwgetch                              Y        Y       Y
  106.       ungetch                               Y        Y       Y
  107.  
  108. **man-end**********************************************************************/
  109.  
  110. static WINDOW *w;            /* to reduce stack usage   */
  111.  
  112. /* this define to get around DOS libraries conflict */
  113. #define getch PDC_getch
  114. /***********************************************************************/
  115. int    PDC_getch(void)
  116. /***********************************************************************/
  117. {
  118. #ifdef PDCDEBUG
  119.     if (trace_on) PDC_debug("getch() - called\n");
  120. #endif
  121.  
  122.     if (stdscr == (WINDOW *)NULL)
  123.         return( ERR );
  124.  
  125.     return(wgetch(stdscr));
  126. }
  127. /***********************************************************************/
  128. int    wgetch(WINDOW *win)
  129. /***********************************************************************/
  130. {
  131. extern    int    c_pindex;        /* putter index           */
  132. extern    int    c_gindex;        /* getter index           */
  133. extern    int    c_ungind;        /* ungetch() push index   */
  134. extern    int    c_ungch[NUNGETCH];    /* array of ungotten chars */
  135. extern  WINDOW*    _getch_win_;
  136.  
  137. /*    signed    key; MH*/
  138.     int    key;
  139.     bool    cbr;
  140. /*    static    chtype    buffer[_INBUFSIZ];MH*/    /* character buffer */
  141.     static    int    buffer[_INBUFSIZ];    /* character buffer */
  142. #ifdef UNIX
  143.     short display_key = 0400;
  144.     bool cbreak_set = FALSE;
  145. #else
  146.     short display_key = 0x100;
  147. #endif
  148.  
  149. #ifdef PDCDEBUG
  150.     if (trace_on) PDC_debug("wgetch() - called\n");
  151. #endif
  152.  
  153.     if (win == (WINDOW *)NULL)
  154.         return( ERR );
  155.  
  156. /* wrs (7/31/93) -- System V curses refreshes window when wgetch is called */
  157. /*                  if there have been changes to it and it is not a pad */
  158.     if( (! (win->_flags & _PAD)) && (! win->_nodelay) ) 
  159.     {
  160.         if( is_wintouched(win) )
  161.             wrefresh(win);
  162.     }
  163.  
  164.     _getch_win_ = win;
  165.  
  166.     if (c_ungind)    
  167.     {            /* if ungotten char exists */
  168.                         /* remove and return it */
  169.         if ((! (win->_flags & _PAD)) && (win->_nodelay))
  170.         {
  171.             if ( is_wintouched(win) )
  172.                 wrefresh(win);
  173.         }
  174.         return( c_ungch[--c_ungind] );
  175.     }
  176.  
  177.     if ((!_cursvar.raw_inp) && (!_cursvar.cbreak))
  178.     {
  179.         /*
  180.          * if normal
  181.          */
  182.         if (c_gindex < c_pindex)
  183.         {
  184.             /*
  185.              * and data in buffer
  186.              */
  187.             return( buffer[c_gindex++] );
  188.         }
  189.     }
  190.  
  191.     w = win;        /* static for speed & stack */
  192.     c_pindex = 0;        /* prepare to buffer data */
  193.     c_gindex = 0;
  194.  
  195.     for(;;)            /* loop for any buffering */
  196.     {
  197.  
  198. #ifdef UNIX
  199.         if (!(_cursvar.raw_inp || _cursvar.cbreak))
  200.             {
  201.             cbreak();
  202.             cbreak_set = TRUE;
  203.             }
  204.         if (w->_use_keypad)
  205.             key = PDC_sysgetch();
  206.         else
  207.             key = PDC_rawgetch();
  208.         if (cbreak_set)
  209.             nocbreak();
  210. #endif
  211.  
  212. #if defined(DOS) || defined(OS2)
  213.         if (_cursvar.raw_inp)
  214.         {
  215.             /*
  216.              * get a raw character
  217.              */
  218.             key = PDC_rawgetch();
  219.         }
  220.         else
  221.         {
  222.             /*
  223.              * get a system character
  224.              * if break return proper
  225.              */
  226.             cbr = PDC_get_ctrl_break();
  227.             PDC_set_ctrl_break(_cursvar.orgcbr);
  228.             key = PDC_sysgetch();
  229.             PDC_set_ctrl_break(cbr);    /* restore as it was */
  230.         }
  231. #endif
  232.  
  233. #if defined(XCURSES)
  234.     key = PDC_rawgetch();
  235. #endif
  236.  
  237.         if (w->_nodelay)
  238.         {
  239.             /*
  240.              * if nodelay and no char
  241.              */
  242.             if (key == -1)
  243.                 return( ERR );
  244.             else if ( ! _cursvar.echo ) {
  245.                 if( ! (w->_flags & _PAD) ) {
  246.                     if( is_wintouched(w) )
  247.                         wrefresh(w);
  248.                 }
  249.             }
  250.         }
  251.         if ((key == '\r') &&
  252.             (_cursvar.autocr) &&
  253.             (!_cursvar.raw_inp))
  254.         {
  255.             /*
  256.              * translate CR
  257.              */
  258.             key = '\n';
  259.         }
  260.         if (_cursvar.echo && (key < display_key))
  261.         {
  262.             /*
  263.              * if echo is enabled
  264.              */
  265.             waddch(w, key);
  266.             wrefresh(w);
  267.         }
  268.         if (_cursvar.raw_inp || _cursvar.cbreak)
  269.         {
  270.             /*
  271.              * if no buffering
  272.              */
  273.             return( key );
  274.         }
  275.  
  276.         if (c_pindex < _INBUFSIZ - 2)
  277.         {
  278.             /*
  279.              * if no overflow, put data in buffer
  280.              */
  281.             buffer[c_pindex++] = key;
  282.         }
  283.         if ((key == '\n') || (key == '\r'))
  284.         {
  285.             /*
  286.              * if we got a line
  287.              */
  288.             return( buffer[c_gindex++] );
  289.         }
  290.     }
  291. }
  292. /***********************************************************************/
  293. int    mvgetch(int y, int x)
  294. /***********************************************************************/
  295. {
  296. #ifdef PDCDEBUG
  297.     if (trace_on) PDC_debug("mvgetch() - called\n");
  298. #endif
  299.  
  300.     if (stdscr == (WINDOW *)NULL)
  301.         return( ERR );
  302.  
  303.     if (move(y, x) == ERR)
  304.         return(ERR);
  305.     return(getch());
  306. }
  307. /***********************************************************************/
  308. int    mvwgetch(WINDOW *win, int y, int x)
  309. /***********************************************************************/
  310. {
  311. #ifdef PDCDEBUG
  312.     if (trace_on) PDC_debug("mvwgetch() - called\n");
  313. #endif
  314.  
  315.     if (win == (WINDOW *)NULL)
  316.         return( ERR );
  317.  
  318.     if (wmove(win,y, x) == ERR)
  319.         return(ERR);
  320.     return(wgetch(win));
  321. }
  322. /***********************************************************************/
  323. int    ungetch(int ch)
  324. /***********************************************************************/
  325. {
  326. extern    int    c_pindex;        /* putter index */
  327. extern    int    c_gindex;        /* getter index */
  328. extern    int    c_ungind;        /* ungetch() push index */
  329. extern    int    c_ungch[NUNGETCH];    /* array of ungotten chars */
  330.  
  331. #ifdef PDCDEBUG
  332.     if (trace_on) PDC_debug("ungetch() - called\n");
  333. #endif
  334.  
  335.     if (c_ungind >= NUNGETCH)    /* pushback stack full */
  336.         return( ERR );
  337.  
  338.     c_ungch[c_ungind++] = ch;
  339.     return( OK );
  340. }
  341.